COMMENT ⊗   VALID 00011 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	ABSTRACT 
C00004 00003	STEP BY STEP INSTRUCTIONS FOR A BASIC SOUND PROGRAM.
C00016 00004	INPUT FOR MUSIC PROGRAMS:
C00026 00005	MUSIC COMPILER, WORD CONVERSION, AND D/A PROGRAMS:
C00033 00006	
C00036 00007	MISCELLANEOUS TECHNIQUES:
C00038 00008	MISC. FILES AND PROGRAMS
C00049 00009	APPENDIX NEWMUS
C00051 00010	CHANGES, ADDITIONS, ODDS AND ENDS
C00056 00011	ABRIDGED EDIT MODE COMMAND LIST
C00065 ENDMK
C⊗;
ABSTRACT 
LRNMUS is an information source for general music synthesis programs.
Familiarity with the Monitor Command Handbook, MUSIC.TVR[UP,DOC], and
SCORE.LCS[UP,DOC] is assumed exept for the STEP BY  STEP INSTRUCTIONS
FOR A  BASIC SOUND PROGRAM  which can  be waded through  by beginners
with  some help.   Knowledge of SAIL (or  ALGOL) is not  essential,but
strongly recomended. This file further assumes the user has access to
someone familiar with AI Lab  music programs who can fill in the gaps
which will undoubtedly exist between what  you want to know and  what
is supplied here.  This file attempts only to anticipate the broadest
questions of procedure. "Ours is not the reason why..."

Gareth Loy [ ,DGL] is the proprieter of this file.  Comments and questions
are welcome.
STEP BY STEP INSTRUCTIONS FOR A BASIC SOUND PROGRAM.
NOTE: Statements  in quotes are  computer responses to  your actions.
I've left out a lot of things in this section that might be helpful
(like how to recover from some mistakes) in the interest of coherency.
Also, changes can be expected in the programs at any time which may
not be reflected here.

This won't make any sense yet, but just remember it for later:
GENERAL OMNIBUS ERROR RECOVERY FORMULA:
	If something goes wrong after you have done the R NEWMUS command
	and are inside NEWMUS  (such as an error message, or the
	computer appears to be stuck by what you've done) you can
	save all that you have successfully loaded and continue from
	where things got wierd by doing the following: Type
<call>		
		That's the key in the upper right hand corner.
"↑C"
		You are now back to the monitor level where you were
		before you typed R NEWMUS.  Now to recover, type
S<cr>
		That is, type S then the <return_key>.
"INPUT"
		Now you are back to the first computer response after
		the R NEWMUS command, but everything the computer
		accepted from you up to the point you goofed is still
		there (such as the arrays you declaired, the 
		instrument, etc.)

       First  it  is  necessary to  connect  the  digital  to  analog
       converter (DAC or  DA) to a loudspeaker, either the four track
       facility in the music room or the monitor speaker  attached to
       your console.   The easiest  thing is  to hook up  the console
       speaker for which you type: 
<break>4U 
       This will not show up on the console.   There is a volume knob
       attached to the  speaker box, turn it to half-way.  To connect
       the 4 channel sound system, find the section on ANALOG ASPECTS
       and MONITOR  SPEAKERS on page  6, follow those  directions and
       report back here. 
	Type:
R NEWMUS<cr>
		NEWMUS is a music compiler which will take all the following
		information and from it compute the waveform and play it.
"INPUT?"
                When NEWMUS says this, it is expecting a file name.  We're
               not dealing with that yet so type:
<cr>
                (that means carriage return).  NEWMUS will type:
">"
  		O.k., now NEWMUS will accept input from your console, so
		type:
SETSPEED;
        	Note the existance and location of the semicolon. Semicolons 
		must end all declarations and statements (with exceptions as
		noted).
		SETSPEED  controls the number of channels and the speed that
		NEWMUS will compile the intrument we will write.
"number of channels:" (you type:) 1 <cr>
"sample rate:" (you type:) 25000 <cr>
"SPEED=2."
">"
 		Ready for more input so type:
ARRAY F2 (512);	

"ARRAY F2"      	
">"
               This creates an array of 512 locations numbered from 0
               to 511 in which we will store the shape of a wave used
               in our basic instrument.  The array is called F2.   F1
               is  alrea   dy  supplied  by  NEWMUS   and  is  loaded
               automatically  with numbers representing  a sine wave.
               The name F2  ("function" 2) is arbitrary.  Remember to
               put the semicolon after the declaration. 

       This  terminates the  list of  declarations  required for  our
       purposes.   There could  also be  other things here  such as  a
       VARIABLE statement,  which  just  says  that  such-and-such  a
       letter or  word,etc. exists as  a location in the  memory that
       can  store a value.  Now to  specify the shape  of the arrays,
       type: SEG(F2); You will be put into a graphic representational
       mode. 
		Type:
0 0 <cr>
                and note the result.  The first number is the amplitude
		(y axis), the second is the x axis increment at which this
		amplitude will be.  Succeeding pairs of numbers just continue
		this process until the number 100 is reached. 
1 10 <cr>
0 100 <cr>
                If after you reach 100 you type <cr>, the function will 
		display. 
                To end the display type:
0<cr>
">"
		If you want to see what the function looks like again, type:
SEE(F2);
        	When you're through, type:
0<cr>
		F1 was supplied by NEWMUS and was constructed by SYNTH,
		which operates like SEG. See pg.∀.


        Next comes the instrument definition. Type:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
OSCIL(U1,MAG*P3,F1);
OUTA←OUTA+U2;  <Note:to type the left arrow,depress the <TOP> key, 
END;           <then the "J" key,on "top" of which  lives the left arrow.
		See page 4 for an explanation of these terms.
"INSTRUMENT FUT"  
		That tells you you did everything o.k. and that FUT 
		exists as a valid instrument.

        Next comes the list of parameters which the instrument will play. 
	Type:

PLAY DA:1.0; FUT 0 1 440 1000;FINISH;		

Please note that following the DA is a colon.  The mark between  the "1.0"
is a period.
DON'T EVER LEAVE A SEMICOLON (or colon) OFF!!!
It is possilbe that you will get a message like:
"XGP in use. Wait for it to finish?"
If this happens, type:
NO

Now the  computer is gobbling  up your data  and spewing  out numbers
into  an output  file.  It  should be  left alone. This  sound seldom
takes  more  than   a  minute  to  compute.     Longer  sounds   take
proportionally more time.   You should have either  fired up the four
track setup  (as per ANALOG ASPECTS) or attached your monitor speaker
to the DA, because suddenly,  when you least expect it, a  sound well
LEAP! out at you. 

If you wish to hear it again, type:
<alt>P<cr><alt>   When you type the second <alt>, you get the sound again.

To make the sound louder, turn the volume knob to the right.

If you want to play a different note with this same instrument, rewrite the
PLAY statement using the following as a guide.
	When writing a PLAY statement directly into NEWMUS like  you are doing 
	put the entire statement on one line.  Follow the format as above
	until the first number after the word FUT.  These four numbers
	are the four parameters we have declaired in the instrument deffinition
	as P1,P2,P3 and P4.
       -The first number (P1) tells NEWMUS how long after the beginning
	of the playback the note is to sound. Since we are playing only
	one sound we want it to be 0 so we will hear it imediately.
       -The second number is the length of the note to be played.  One
 	second is recommended because the computing time is short.
	If you are experimenting, it wastes less time.  But if you want to
	change it, you must also change the number after "DA:" to match.
       -P3 is the pitch of the note.  Write either the frequency (Hz) of
	the note, or for the equal tempered tuning, a letter from A - G.
	Sharps are possible by following the letter imediately with S.
       -P4 is the volume of the note. Any value between 0 and 2047 will do.
Example of another note:
PLAY DA:5.0 FUT 0 5 AS 2000; FINISH;

When you are through, leave NEWMUS by typing:
<alt> EXIT <cr>.
	the computer then puts you back to monitor mode:
"EXIT"
"↑C"
INPUT FOR MUSIC PROGRAMS:
Input is made  up of an  instrument definition, a  parameter list,and
other   information  the   compiler  needs   which  we'll   call  the
initializing list. The Stanford music compiler reads this information
from one or  more files. Creating several files  for this information
is  suggested.  However,  all  the  statements  ,  declarations, etc.
described below can be  added from the console directly  into NEWMUS.
See page  3. The  advantage is flexibility  in seting things  up, the
disadvantage is that  you must then  retype the entire  event if  you
either leave  the  NEWMUS environment,  or want  to change  something
after it has been compiled. 

INITIALIZING LIST:
First, learn how to create files using the E editor. See page 11.

Create a file (maybe called INIT, or something).  Into it put the
following declarations:


SETSPEED;<# OF CHANNELS> <SAMPLING RATE>  (don't forget ;)

(typical values: SETSPEED; 1 25000). This sets the sampling rate.
	
ARRAY F2,F3,...,Fn(512);

F2,...Fn are functions (sine waves, envelope functions, etc.)
to be loaded with the instrument. (512) is the current size of a
memory block. F1 is always supplied with NEWMUS as a sine wave.
This can be overriden of course.
VARIABLE ⊂variable name⊃,⊂v.n.⊃,⊂v.n.⊃;

        A number of variables
	are specified in NEWMUS automatically, such as the letters of the
	musical scale with their Hertz numbers (see APPENDIX NEWMUS).
	You can create variables for other purposes with the above format.

	Other things can go into this file, for instance, you can tell
yourself the next file to read by writing:

PRINT "Next file name";

When the music compiler (NEWMUS) loads this file, it will print 
this statement afterwards.

Basicly you want to put everything in the initialization list
that you don't want to have to declare over and over again.


INSTRUMENT LIST
Create a file for your instrument definiton.
Now that you have arrayed the functions, specify their shape with either 
SYNTH or SEG, e.g.:

SYNTH(F2); 1 1 999 

(Note the location of the ;.)
This creates in F2 a sine wave with harmonic 1 (the fundamental) and 
amplitude 1. 999 terminates the SYNTH list.  There is an extended mode:

SYNTH (F2); 99 1 1 90 1 999  

where 99 enters the mode, 
harmonic = 1, amp.=1, phase angle =90degrees, offset constant=1, 999term.

SEG(F3); 0 0 1 1 0 100 

(Note the semicolon.)
This allows  functions to  be drawn  in line  segments. The  function
described  has amplitude 0 at  location 0, amp.  1 @ loc.1,  0 @ 100.
Typing location # 100 terminates SEG.  SYNTH and SEG functions can be
created while runing NEWMUS, and will display the waveform. Just type
the above  statements up to the ";", then hit ⊂cr⊃. The waveform will
begin displaying and instructions on how to alter it will be printed.
You  can see  existing functions  graphicly in  NEWMUS by  typing SEE
(<function name>);.

Now  the instrument:
	INSTRUMENT FUT;
	OSCIL(P4,MAG/P2,F2);
	OSCIL(U1,MAG*P3,F1);
	OUTA←OUTA+U2;
	END;
where: 

INSTRUMENT <name>;
begins the instrument list. This is a special kind
of DO list which the music compiler can read.  Like any DO
list,   it   must   be  terminated   by   END;   see   below.

OSCIL(<amplitude>,<frequency>,<function>);
There are many kinds of oscils.
See the MUSIC  MANUAL listed in FILES, page 8 below.    

MAG
is  the magic number  specifying the  ratio of 512/sample  rate.
The  length of stored functions  in NEWMUS is 512  samples long.  The
ratio (512/sampling  rate) establishes  a base  frequency which  when
mulltiplied by  the desired frequency  number (in this  case,P3) will
sample  the  512  increment long  function  at  intervals  which will
produce the desired frequency. A further explanation  of this subject
can be found in MUSIC.TVR[UP,DOC]. This is also a good question for
a music programer. 

Pn is a specialized variable called a parameter number, e.g. in the
instrument above, P1,P2,P3, etc. are variables which will be supplied
their values from the PLAY statement described below.

Un is the output of a unit generater(numbered  in order  of  entry) 

OUTA  is  the output  block absorbing  this instrument.

END;(←note  semicolon;) this  ends the instrument list.

Comments can be added to this or any list by typing:

COMMENT say anything here until you write a semicolon;

Alternate comment form:

< say anything here until a semicolon;


INSTRUMENT WRITING CONSIDERATIONS:
Newmus is set up so  that P1 always determines the begin  time of the
instrument. For instance, if you want FUT to play at time 0, P1 would
be listed in your note list  as 0. Also, P2 is reserved to  represent
the total duration of the note  being played. So, P2 does two things:
it  tells the system  how long to  make the file  the instrument will
play into, and it also  is available to determine the length  of time
the  instrument will actually  play.   You CAN have  the instrument's
duration controled in another variable, but  P2 must still be in  the
note list  to represent the  length of the  file the  instrument will
read  into.   This information  is  given here  instead of  under the
parameter list heading below because  it affects how you define  your
instruments as well as how you write their note lists.


PARAMETER LIST
Here's where you tell the instrument what to play. 
Create a file for parameters.

PLAY;INSTRUMENT NAME P1 P2 P3 P4 ...Pn; 
Typical PLAY statement for the instrument FUT described above:
PLAY FUT 0 1 440 1000;FINISH;
The parameter list must  end with 
FINISH;

The play statement is like a specialized block in SAIL with PLAY;
replacing BEGIN, and FINISH; for END;
Please see INSTRUMENT WRITING CONSIDERATIONS  above.


MUSIC COMPILER, WORD CONVERSION, AND D/A PROGRAMS:
The NEWMUS compiler  will be used here.  SCORE does much of  the same
kinds of things,  (it is either more efficient or less efficient than
NEWMUS depending  on  what you want to do)  and  is well  documented  in
SCORE.LCS[UP,DOC].


NEWMUS:
	NEWMUS is a compiler, and is the vehicle by which instruments
	are coupled with their parameters.  One or more files are
	created to contain the numeric representations of the waveform.
	Type:
R NEWMUS
	After some preliminary statements, it types:
Input:  
       Type file  names of initialization,  instrument, &  note lists
       one at a time.   When it says "Input?" it expects a file name.
       To  do  anything  else,  like  to  make   declarations,  write
       functions, or to write instruments, etc.  type ⊂cr⊃ first.  To
       return to input mode, type ⊗⊂cr⊃.  If you get an error message
       "Storage full",  type  <CALL>, and  restart  using the  FREEZE
       method,  see below. Among  the variables  that are  given with
       NEWMUS are the Hz for pitches of the equal temperament  scale:
       A:440, AS(A SHARP):466.16,...GS.  See  APPENDIX NEWMUS.  Array
       F1 is  given as a simple  sine wave.  If you  want to watch it
       compile, see MONITE[1,MUZ] below:
Output:  
	Name a file for storage of computed samples. There should be an
	integer(or letter) extention to the file name (e.g. TEST.1). 
	This is because,if your sound file will be longer than about two
        seconds, NEWMUS will
	automatically create more files with extensions n+1 to contain it.
	"MAX AMP" is part of data printed when compilation is complete 
	used to indicate the largest sample. Remember it.
	If you have no more input, then type:
<alt> EXIT

NMUSIO:
	NMUSIO is a program which converts one or more 18 bit sound files
	as produced by NEWMUS into one long 12 bit soundfile  acceptable
	as input to the D/A converter.
	Type:
R NMUSIO
Input:
	Type NEWMUS output file name. If NEWMUS created more than one file
	for output (the extension is incremented one for each additional
	file created),load the files this way: <filename.ext>-<last ext>.
	For instance:FOO.1-6.
Output:  
	Make up a storage location. Since this will be a sound file,you 
	might want to use the extension capability to identify this.
Convert to 12 bit?
	Y(es).  <cr> will copy input file into output without conversion.
Max Amp: (Write it in here, or <cr> and NMUSIO will find the figure.)
	NMUSIO then converts the files and types:
More input?
       If NEWMUS  had to  create more  files, you  add them here,  so
       answer Y(es); Else N(o). 
Input:
	Write in the additional file name and that file will be joined to the
	end of the new file.
Finishing input?
	Y or N. NMUSIO will CALL itself.



 	The two follownig programs play the sound files through the DA.
R DSKPLY
	will explane itself. (honist!)
	This program will play sound files even if the XGP is busy.
	Set up the sound file, and continue to default  (tnat is, type
	<cr> every time) until it says GO?... then Y(es).
	To leave DSKPLY,type call, then F<cr> to make sure the XGP is 
	unhooked from your job.


For an alternate way to play sounds, type:
R MPLA to play multiple lists. TTY types:
> (put file name here, then <cr>)
> (if more files are to be played add them here, else just <cr> again).
Play it? Y(es).  
   	If you want to play a different file, N(o).
	If you are going to play more than one speaker, 
	after Input? type <S><cr>. Then either accept or replace values of
	variables.
	Leave MPLA  by doing an <alt>X, rather than a
<call> or else you will leave the XGP assigned to your job and somebody may
come looking for you...
(Question of the week, "What does the XGP have to do with the DAC, anyway?
Answer: they both are controled from the PDP 6 which is not big enough for both.

ANALOG ASPECTS  
Music room:
Switch in back of silver volume box beside Scully 280,
if up, moniters the decks inside the cabinet, if down, the Scully.
Scully must be in record mode,  with volume up for channels outputing.
Set Record level to about 5, Input to Line. Put Dolby in Rec mode.
D/A:
Sampling rate of the 4 channel d/a is usually set at 25khz, with the
corresponding low-pass filter cutoff of 12.5khz.
If you have reason to believe the d/a needs to be adjusted, it exists
at KLUDGE BAY 2 in the machine room.  The d/a proper is the topmost 
chasis.  The bottom most chasis is the filter.
Switch positions: channels 4   3   2   1 left to right as you look 
at them.
A/D Nothing is known at this point about the a/d.

MONITOR SPEAKERS
If you  are not working  in the  music room, you  can switch the  TTY
audio channel to channel  1 of the D/A by typing BREAK 4 U (See Audio
Switch Control, 2.9, Monitor Command  Manual). BUT the D/A will  also
output to the music room,and if there are people using the D/A there,
they  will be  clobered by your  sounds. So,  send them  a message to
expect your  sounds, as it  is quite  unnerving to  be jolted out  of
meditation by another's static. See MAIL in Monitor Command.  Ttys 24
and 45 are the ones in the musiic room.
Or you might move your project to the music room to play your sounds. Type:
AL ⊂prj,prg⊃ ⊂cr⊃ to alias to a tty in the music room.
AL ⊂cr⊃ returns the tty to its previous user. Or,
DET(atch) your job, move to an unused tty in the music room and
ATTACH ⊂job #⊃ [prj,prg] ⊂cr⊃. You are now attached to the new tty.
				******
MISCELLANEOUS TECHNIQUES:

FREEZE METHOD:
If you get squeezed for core, start over doing the following:
R NEWMUS 25 (this specifies 25K core)
	now add input files.
	After compilation write 
<ALT>FREEZE 
	when frozen, exit to moniter and write
SAV <filename, anything besides NEWMUS>
	Your program will be saved in the required core. 
	You now have a dump file with that filename which contains,
	besides NEWMUS, all the data you have put into it. 
	Address it as follows:
RU <dump_file_name>

	
EDITING FROM NEWMUS:
Given an error in an input list, you have the option to edit the
error in the file without leaving the NEWMUS environment.  Type E, the 
program then moves to the location of the error.  Correct it, then type
⊗X,then GO to return to your location in NEWMUS.


MISC. FILES AND PROGRAMS


INFORMATION FILES:
MUSIC.TVR[UP,DOC]
SCORE.LCS[UP,DOC]
USEMUS.MAN[MAN,LCS] FOR MUSIC 10


FUNC, a program for using lightpen to write functions, and/or
	to write functions into files. Lightpen works only from III's.
	Type 
R FUNC  
	After it enters, type ⊂cr⊃.  It will say
SEG OR SYNTH?
        Say either, usually SEG.
       When  the  graph  is displayed,  type  L  for  lightpen,  move
       lightpen  to location of  the circle  of dots, push  button on
       lightpen,  and draw.    To  fix  a  point,  hold  lightpen  at
       location, type ⊂cr⊃.  Follow directions until it says 
ADD TO EXISTING FILE?
	type N(o).  Then it will ask
TYPE FILE NAME
	write a filename without extension. Then it will say
TYPE FUNCTION NAME
	so write in a function name. 
	It will create the file with the extension .DAT.
	You can refrence this file from NEWMUS like any other file.
	Later, add functions to this file by saying Y(es) to 
"ADD TO EXISTING FILE?"

FUNKY[MIX,MUZ] a file for manipulating arrays.
FUNKY.INF[MIX,MUZ] for information on FUNKY.

WAVE[1,MUZ] a program to display samples of a sound created 
with NEWMUS.  It will not take files with extensions.  Copy the file
into a file without one, then RU WAVE[1,MUZ] and do what it says.

MONITE[1,MUZ]  a file  containing  the  instrument MONITER,  used  to
display  word blocks  in NEWMUS  while they are  being computed.   It
isn't an instrument you will hear, but a kind of  visual loudspeaker.
So it's function is to display another  instrument .  So load it with
your  instrument,  and  write  a  parameter  list  for MONITER  where
P1=starting time,  P2=duration, P3 is  the amplitude,  and P4 is  how
often to display. Typical values might be 0 1 1000 2;

S  This is a program, not a file, containing a display program for viewing
sound files in 12 bit and other formats.  It also contains  filters
(lowpass, hignpass). It has some internal documentation.  Type:
R S It will type:
* 
	For information type either "?" or HELP, or see JAM. Good luck!

RU CREV[MIX,MUZ] a file for creating reverb instruments. For info. type 
HELP. You want to treat the file like an automatic equation solver.  The
equation takes two supplied values  and finds the third. The variables are
Reverb_time,Gain,& Delay_time. To solve for Gain as the unknown type G,
then enter values for the other two independent variables. 
When the solution is reached, CREV will write those values into a unit
generator and put it in a file for you.  See Loren Rush for details (MUZ).
Suggested  delay factor between unit generators: .8, gain factor .94.)
Writing good reverb instruments is an intuitive gift.

EGEN [GL,JAM], a file of envelope generators to be used in NEWMUS.
EGEN.INF[GL,JAM], for information on EGEN.

PPSAV  This is a program, not a file, which will create a file and put into
it the contents of your screen.  The file will be called PPSAV.TMP.

NOTICE: Programs and files sometimes change location.  If you are looking
for a file listed here or anywhere, and the computer doesn't find it,
try the following, type to the monitor:
DIR <filename>.<ext>[*,PRG]|[PRJ,*]
The first option will search for the file through all the programer's 
projects, the second option will search through all progects, matching
them against the filename. For example:
DIR FUNKY.INF[*,MUZ] will search MUZ for a project that has FUNKY.INF.
APPENDIX NEWMUS

Pitches given in NEWMUS:
A 	440
AS	466.16
B	493.89
C	261.62
CS	277.18
D	293.66
DS	311.13
E	329.63
F	349.23
S	369.99
G	391.99
GS	415.31
		*************

If computation is interrupetd in NEWMUS for any reason (such as
a parity error, if you type CALL accidently, etc.) restart by typing:
RU <NEWMUS_output_file_name>.SAV <cr>. That will start it again at
the point it was terminated.

If you wish to see a listing of parameters introduced to NEWMUS, type
<alt>LIST<cr>	this lists all variables and arrays declared.
<alt>VARIABLE          "    "      "                    "   .
<alt>ARRAY	       "    "                  "        "   .
**********
There is a unit generator in NEWMUS which routinizes frequencey modulation
called INTRP.  It's parameters are:
NTRP(MAG*<minimum_modulation_index>,MAG*<max._mod._index>,<function>);
These two instruments are equivilent:
INSTRUMENT FUT;
OSCIL(P4,MAG/P2,F2);
NTRP(P5*P6*MAG,P5*P7*MAG,F3);
OSCIL(U2,P5*MAG,F1);
OSCIL(U1,MAG*P3+U3,F1);
OUTA←OUTA+U4;
END;

INSTRUMENT FUT;
OSCIL (P4,MAG/P2,F2);
OSCIL(P7,MAG/P2,F3);
OSCIL(P6+U2,MAG*P5,F1);
OSCIL(U1,MAG*P3+U3,F1);
OUTA←OUTA+U4;
END;
CHANGES, ADDITIONS, ODDS AND ENDS

**********
It is now possible to play sounds through the d/a as soon as they are
compiled in NEWMUS.  To do so, add the code "DA:n.n" where n is the length
of the sound file to be played in seconds (don't write integer values,the
dot is aparently necessary). This statement is placed in the PLAY statement
thus:

PLAY DA:1.0; FOO 0 1 A 1000;FINISH;  

Once the sound has played once in NEWMUS, it can be played again immediately
by typing from TTY mode:
<alt>P<cr><alt> 

and the sound will play when you type the second <alt>.

**********
You can have NEWMUS  create a 12 bit sound file  directly which saves
you from having  to run NMUSIO by typing the following when asked for
an output file name:           
"Output:"<file_name>.<ext>/SOUND/BYTESIZE=12<cr>

**********
If you are doing a long compute in NEWMUS, and you want to stop it, or it
stops itself for some reason (error, etc.) it can be restarted by the following:
RU<output_file_name>.SAV and it will start up where it left off.
Furthermore, the job that is doing the compute can be detatched from your
terminal but still continue running by doing the following:
	Start the compute
	type C↑
	type CF
	type KATT<job_number>  (that stands for kill attached job).

**********
Within an instrument it is possible to write a statement that will be
executed only at the time the instrument is being used to generate its
waveform.  The format is:
INSTRUMENT <name>;
    I_ONLY
	<statements>
    END;
<continuation_of_instrument_list>;
END;

**********
It is possible to redefine functions from a PLAY statement.  But the
redeffinition must come after the next call to that instrument, e.g.:

PLAY; FUT 0 1 A 1000; FUT 1 1 C 1000; SEG(F2); 0 0 1 100 FINISH;

This has the effect of redefining F2 for the second call to FUT.
The compiler calculates everything according to the latest begin time
(P1), hence, for the redeffinition to affect the next note, it must come
after the new begin time.

**********
USEFUL TIDBITS:
 	MAG/Pn(usually pn←p2) is note duration. MAG*Pn is fqy.
 	Maximum amplitude processed by the d/a = 2047.
	PRINT ⊂string⊃; will print the values, assuming they exist.
	SEE (array); will display it.
	PUT (FUNCTIONn ⊂from 0→512⊃)⊂number⊃; to change an 
	increment in a function.
	<alt>VARIABLE writen in NEWMUS will list all available variables.
	<alt>FUNCTION    "    "    "     "    "    "     "     functions.
	<alt>LIST will list everything indiscriminantly.
	C<space>0 will release the XGP,DA, other device attached by MPLA, etc.
        WHO<space>R | M : R=system run time display; M=your own programs.
	TO PASS NEGATIVE VALUES IN A PLAY STATEMENT, IT IS NECESSARY TO 
	PRECEED THEM WITH A COMMA,otherwise the compiler wouldn't know if
	it were a new peram. or an algebraic variable.
	
ABRIDGED EDIT MODE COMMAND LIST
	α MEANS ⊂CONTROL⊃ KEY
	β   "   ⊂META⊃    "
	⊗   "   ⊂META-CONTROL⊃
	<cr> "  ⊂RETURN⊃
	|   "   YOU HAVE A CHOICE BETWEEN WHAT`S IN THE BRACKETS
The E editor is an aid to writing files.  It supplies a list of commands 
with which files can be writen quickly and easily.  To learn the commands,
get to the monitor level, and type:
HELP ETEACH    	with a carriage return and follow instructions.

Another information source  is in E.ALS[UP,DOC] which can be addressed
either from the monitor, or while editing a file. Enter a file by typing:
ET <filename><cr> as usual, then type α? (that is, <CONTROL>?).

The following list is incomplete, possibly inaccurate, and probabily misleading.


	E EDITOR MODE COMMANDS
ET ⊂FILENAME⊃ TO EDIT A FILE
CET ⊂FILENAME⊃ TO CREATE A FILE.

	MISC.
⊂FORM⊃ KEY WINDOWS AND PAGES AUTOMATICALLY.
⊗P GOES TO NEXT PAGE
⊗W MOVES BOTTOM LINE TO TOP.
⊗J   "   CURRENT  "   "  "  .
⊗L   "   TOP      "   " BOTTOM.
⊗⊂PAGE #⊃⊗P MOVES TO THAT PAGE.
⊂alt⊃ ERASES COMMANDS.
⊂RPT⊃⊗D DELETES LINE.
⊗⊂RPT⊃C DUPLICATES A NUMBER OF LINES.
⊗Q DUPLICATES A LINE ABOVE CURRENT AND MOVES ARROW TO IT.
α⊂SPACE⊃ MOVES CURSOR TO THE RIGHT. α⊂VT⊃ MOVES IT BACK.
TY⊂FILENAME⊃ TO TYPE A FILE ON THE MONITER.
α⊂BREAK⊃ STOPS SCROLLING.
α⊂TAB⊃ MOVES CURSOR TO END OF LINE. 
α ⊂CR⊃ TO CONTINUE A PROGRAM IF YOU CUT YOURSELF OFF.

	INSERT MODE
⊗⊂CR⊃ ENTERS INSERT MODE.
α⊂CR⊃ LEAVE INSERT MODE.
⊂ALT⊃ ELIMINATES THE GAP IF NOTHING IS ENTERED ON LINE.
⊂RPT#⊃⊗⊂CR⊃ INSERTS BLANK LINES WITHOUT ENTERING INSERT MODE.

	ATTACH MODE
⊂RPT⊃|⊗F⊗R ENTERS ATTACH MODE                            
⊗E TERMINATES AND UPDATES LOCATION OF ATTACHED LINE.
⊗R RETURNS LINES TO ORIGINAL PLACE
⊗K KILLS LINES ATTACHED.
⊗E LEAVES ATTACH MODE.

	EXTEND MODE
⊗X ENTERS THE MODE.
⊗X "MARK" MOVES MATERIAL BELOW ARROW TO NEXT PAGE.
⊗X "DELETE" ELIMINATES PAGE MARK BETWEEN ONE PAGE AND THE NEXT.

	TO BREAK A LINE
⊗⊂CR⊃ BREAKS THE LINE AT CURSOR AND ENTERS INSERT MODE.
β⊂CR⊃   "    "    "   "     "   BUT NOTHING ELSE.
(α⊂CR⊃ INDICATES LINE TOO WIDE IF LINE INDENTS TO LEFT.)

	TO INSERT IN A LINE
β⊂LETTERS⊃|⊂SPACE⊃|⊂TAB⊃|⊂BS⊃.
αI TO ADD CHARACTERS IN A LINE WITHOUT HAVING TO HOLD DOWN THE β KEY.

	SEARCH MODE
⊗F⊂STATEMENT STRING⊃ FINDS THE VERBATEM STRING, COUNTS LINES TO THAT LINE,
⊗X FIND_⊂STRING⊃⊂CR⊃. SEARCHES ACROSS PAGES TO FIND THE STRING.
αS ⊂STRING⊃ MOVES CURSOR WITHIN LINE TO THE STRING LOCATION.

				******
	TV EDITOR COMMANDS
TV EDIT A FILE WITH TV.
CTV CREATE A FILE WITH TV.
⊗X "SWITCH"⊂FILENAME⊃ MOVES ATTACHED LINES TO NEW FILE.                 
				******
	TO MOVE INFORMATION BETWEEN FILES
TV ⊂File with info⊃ to locate it.
→ place cursor at top of info.
⊗F⊂bottom line of info⊃⊗A to attach info.
⊗X SWITCH ⊂filename of destination file⊃.
				******
	AIDS TO EDITING
DIR lists all files on the disk in this prj,prg.
DEL ⊂filename⊃ will delete that file.
DEL *.*[PRG,PRJ]/ASK will sequence through files asking to save or not.
α⊂CR⊃ IF THE MONITOR DIDN'T LIKE YOUR COMMAND, WILL PUT IT IN EDIT MODE.
				******
	JUSTIFYING PAGES
⊗A TO BOTTOM LINE, THEN ⊗X JU.